{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PPO, Actor-Critic Style\n",
    "_______________________\n",
    "&nbsp;&nbsp;**for** iteration=1,2,... do<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**for** actor=1,2,...,N do<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Run policy $\\pi_{\\theta_{old}}$ in environment for T timesteps<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Compute advantage estimates $\\hat{A}_1,\\dots,\\hat{A}_T$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;**end for**<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Optimize surrogate(代理人) L wrt $\\theta$,with $K$ epochs and minibatch size $M \\leq NT$<br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;$\\theta_{old} \\leftarrow \\theta$<br>\n",
    "&nbsp;&nbsp;**end for**\n",
    "_______________________"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loss Function L的数学公式为:\n",
    "$$\n",
    "L_t^{CLIP+VF+S}(\\theta)=\\hat{\\mathbb{E}_t}[L_t^{CLIP}(\\theta)-c_1L^{VF}_t(\\theta)+c_2S[\\pi_\\theta](s_t)]\n",
    "$$\n",
    "其中，$L^{CLIP}(\\theta)=\\hat{\\mathbb{E}_t}\\big[min(r_t(\\theta)\\hat{A}_t,clip(r_t(\\theta), 1-\\epsilon,1+\\epsilon)\\hat{A}_t)\\big]$, $r_t(\\theta)=\\frac{\\pi_\\theta(a_t|s_t)}{\\pi_{\\theta_{old}}(a_t|s_t)}$<br>\n",
    "$L^{VF}_t=(V_\\theta(s_t)-V_t^{targ})^2$ **critic loss**<br>\n",
    "S 为奖励熵，保证足够多的探索(写A2C的时候已经OK)<br>\n",
    "$c_1, c_2$为参数\n",
    "#### $L^{CLIP}和r的关系如下(为了保证\\pi_\\theta和\\pi_{\\theta_{old}}的差值不会很大,满足TRPO中两者方差变化不大的要求)$：\n",
    "<img src=\"../assets/PPO_CLIP.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### GAE(high-dimensional continuous control using Generalized Advantage Estimation)\n",
    "We address the first challenge by using value functions to substantially reduce the variance of policy gradient estimates at the cost of some bias, with an exponentially-weighted estimator of the advantage function that is analogous to TD(λ). <br>\n",
    "\n",
    "改进了advantage function的计算方式。将advantage function进行类似于TD(λ)的处理<br>\n",
    "\n",
    "#### 推导过程\n",
    "1. 原始的advantage function : $\\delta^V_t=r_t+\\gamma V(s_{t+1})−V(s_t)$\n",
    "2. $在位置t时,其后k个 \\delta 折扣相加$ : \n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\hat{A}^{(1)}_t&:=\\delta^V_t&&=-V(s_t)+r_t+\\gamma V(s_{t+1}) \\\\\n",
    "\\hat{A}^{(2)}_t&:=\\delta^V_t+\\gamma \\delta^V_{t+1}&&=-V(s_t)+r_t+\\gamma r_{t+1}+\\gamma ^2 V(s_{t+2}) \\\\\n",
    "\\hat{A}^{(3)}_t&:=\\delta^V_t+\\gamma \\delta^V_{t+1}+\\gamma^2 \\delta^V_{t+2}&&=-V(s_t)+r_t+\\gamma r_{t+1}+\\gamma^2 r_{t+2}+\\gamma ^3 V(s_{t+3}) \\\\\n",
    "\\hat{A}_t^{(k)}&:=\\sum_{l=0}^{k=1}\\gamma^l\\delta_{t+l}^V&&=-V(s_t)+r_t+\\gamma r_{t+1}+\\dots+\\gamma^{k-1}r_{t+k-1}+\\gamma^kV(s_{t+k})\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "\n",
    "3. $k \\to \\infty, \\gamma^kV(s_{t+k})$会变得非常非常非常小，So :\n",
    "$$\n",
    "\\hat{A}_t^{(\\infty)}=\\sum^\\infty_{l=0}\\gamma^l\\delta_{t+l}^V=-V(s_t)+\\sum^\\infty_{l=0}\\gamma^lr_{t+l}\n",
    "$$\n",
    "4. 所以，$t$ 时刻的GAE可推导为 :\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\hat{A}_t^{GAE(\\gamma, \\lambda)}&:=(1-\\lambda)\\big(\\hat{A}_t^{(1)}+\\lambda\\hat{A}_t^{(2)}+\\lambda^2\\hat{A}_t^{(3)}+\\dots\\big)\\\\\n",
    "&=(1-\\lambda)\\big(\\delta_t^V+\\lambda(\\delta_t^V+\\gamma\\delta_{t+1}^V)+\\lambda^2(\\delta_t^V+\\gamma\\delta_{t+1}^V+\\gamma^2\\delta_{t+2}^V)+\\dots\\big)\\\\\n",
    "&=(1-\\lambda)\\big(\\delta^V_t(1+\\lambda+\\lambda^2+\\dots)+\\gamma\\delta^V_{t+1}(\\lambda+\\lambda^2+\\lambda^3+\\dots)+\\gamma^2\\delta^V_{t+2}(\\lambda^2+\\lambda^3+\\lambda^4+\\dots)+\\dots\\big)\\\\\n",
    "&=(1-\\lambda)\\big(\\delta^V_t\\big(\\frac{1}{1-\\lambda}\\big)+\\gamma\\delta^V_{t+1}\\big(\\frac{\\lambda}{1-\\lambda}\\big)+\\gamma^2\\delta^V_{t+2}\\big(\\frac{\\lambda^2}{1-\\lambda}\\big)+\\dots\\big)\\\\\n",
    "&=\\underbrace{\\delta^V_t+\\gamma\\lambda\\delta^V_{t+1}+(\\gamma\\lambda)^2\\delta^V_{t+2}+\\dots}_{此处计算时使用这个公式(迭代计算)}\\\\\n",
    "&=\\sum_{l=0}^\\infty(\\gamma\\lambda)^l\\delta^V_{t+l}\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 使用高斯分布(正态分布)来实现随机性策略控制连续动作空间\n",
    "1. 高斯分布有两个重要的变量一个是均值 $\\mu$ ,另一个是方差 $\\sigma$ 。$\\mu$ 为高斯函数的对称轴，$\\frac{1}{\\sqrt{2\\pi}\\sigma}$ 为高斯函数的最高点。高斯函数的积分为1。所以我们可以使用它来进行连续动作的sample。方差 $\\sigma$ 越大，分布越分散，方差 $\\sigma$ 越小，分布越集中。\n",
    "2. $\\mu$ 的选择很好把控，经过tanh处理之后+简单的数学变换，使nn输出的 $\\mu$ 在env规定的动作空间内就可以\n",
    "3. $\\sigma$ 的选择,使用softplus函数对sigma进行处理。softplus 公式为$f(x)=\\frac{1}{\\beta}log(1+exp(\\beta x))$, softplus 是 ReLU 的平滑近似值版本\n",
    "4. 高斯分布公式:\n",
    "$$\n",
    "f(x)=\\frac{1}{\\sqrt{2\\pi}\\sigma}exp\\bigg(-\\frac{(x-\\mu)^2}{2\\sigma^2}\\bigg)\n",
    "$$\n",
    "5. 和确定性策略相比，需要考虑每个state采取每个动作的概率，计算量确实比较大。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TRPO\n",
    "简单理解为一次on-policy到off-policy的转换<br>\n",
    "但是为了保证old_policy和new_policy之间方差相差不会太大<br>\n",
    "$$\n",
    "\\begin{aligned}\n",
    "E_{X \\sim p}[f(x)] & \\approx \\frac{1}{N}\\sum^N_{i=1}f(x^i)\\\\\n",
    "&= \\int f(x)p(x)dx=\\int f(x)\\frac{p(x)}{q(x)}q(x)dx=E_{x \\sim q}[f(x)\\frac{p(x)}{q(x)}]\n",
    "\\end{aligned}\n",
    "$$\n",
    "由此，在两者期望相同的情况下，论证方差是否相同\n",
    "$$\n",
    "\\begin{aligned}\n",
    "两者期望:\\quad&\\because E_{X \\sim p}[f(x)]=E_{x \\sim q}[f(x)\\frac{p(x)}{q(x)}]\\\\\n",
    "方差公式:\\quad&\\because VAR[X]=E[X^2]-(E[X])^2\\\\\n",
    "x \\sim p 方差:\\quad&\\therefore Var_{x \\sim p}[f(x)]=\\color{red}{E_{x\\sim p}[f(x)^2]}-(E_{x\\sim p}[f(x)])^2\\\\\n",
    "x \\sim q 方差:\\quad&\\therefore Var_{x \\sim q}[f(x)\\frac{p(x)}{q(x)}]=E_{x \\sim q}\\big[\\big([f(x)\\frac{p(x)}{q(x)}\\big)^2\\big]-\\big(E_{x\\sim q}\\big[f(x)\\frac{p(x)}{q(x)}\\big]\\big)^2\\\\\n",
    "&=\\color{red}{E_{x \\sim q}\\big[f(x)^2\\frac{p(x)}{q(x)}\\big]}-(E_{x \\sim p}[f(x)])^2\n",
    "\\end{aligned}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "两者方差公式的差别在标红的位置，也就是说我们如果使两者$E_{x\\sim p}[f(x)^2]$和$E_{x \\sim q}\\big[f(x)^2\\frac{p(x)}{q(x)}\\big]$的差值较小，那么我们所做的off-policy就是可行的<br>\n",
    "由此，可直观的看出，我们要使p(x)和q(x)的相差较小。因此就有了PPO1中的所使用的$\\beta KL(\\theta,\\theta')$和PPO2中的clip这些都是为了限制两者的范围在一个可接受的合适空间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Normal\n",
    "from torch.distributions import Categorical\n",
    "import torch.multiprocessing as mp\n",
    "# from torch.utils.tensorboard import SummaryWriter\n",
    "import numpy as np\n",
    "from IPython.display import clear_output\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import math\n",
    "import random\n",
    "from statistics import mean\n",
    "import pdb\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x259.2 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_function():\n",
    "    x = np.arange(-10,10,0.05)\n",
    "    plt.figure(figsize=(9,3.6))\n",
    "\n",
    "    plt.subplot(121)\n",
    "    plt.title(\"Gaussian distribution\")\n",
    "    mu, sigma = 0, 10\n",
    "    y = lambda x : np.exp(-((x-mu)**2)/(2*sigma**2))/(sigma*np.sqrt(2*np.pi))\n",
    "    plt.plot(x, y(x))\n",
    "\n",
    "    plt.subplot(122)\n",
    "    plt.title(\"Softplus\")\n",
    "    y = np.log(1+np.exp(x))\n",
    "    plt.plot(x, y)\n",
    "    plt.show()\n",
    "\n",
    "plot_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多线程又双叒叕来了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def worker(worker_id, master_end, worker_end, env_name):\n",
    "    master_end.close()\n",
    "    env = gym.make(env_name)\n",
    "    env.seed(worker_id)\n",
    "    \n",
    "    while True:\n",
    "        cmd, data = worker_end.recv()\n",
    "        if cmd == 'step':\n",
    "            state, reward, done, info = env.step(data)\n",
    "            if done:\n",
    "                state = env.reset()\n",
    "            worker_end.send((state, reward, done, info))\n",
    "        elif cmd == 'reset':\n",
    "            state = env.reset()\n",
    "            worker_end.send(state)\n",
    "        elif cmd == 'reset_task':\n",
    "            state = env.reset_task()\n",
    "            worker_end.send(state)\n",
    "        elif cmd == 'close':\n",
    "            worker_end.close()\n",
    "            break\n",
    "        elif cmd == 'get_spaces':\n",
    "            worker_end.send((env.observation_space.shape[0], env.action_space.shape[0]))\n",
    "        else:\n",
    "            raise NotImplementedError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "class ParallelEnv:\n",
    "    def __init__(self, n_train_processes, env_name):\n",
    "        self.nenvs = n_train_processes\n",
    "        self.waiting = False\n",
    "        self.closed = False\n",
    "        self.workers = []\n",
    "        self.env_name = env_name\n",
    "        \n",
    "        self.master_ends, self.worker_ends = zip(*[mp.Pipe() for _ in range(self.nenvs)])\n",
    "        \n",
    "        for worker_id, (master_end, worker_end) in enumerate(zip(self.master_ends, self.worker_ends)):\n",
    "            p = mp.Process(target=worker, args=(worker_id, master_end, worker_end, self.env_name))\n",
    "            p.daemon = False\n",
    "            p.start()\n",
    "            self.workers.append(p)\n",
    "        for worker_end in self.worker_ends:\n",
    "            worker_end.close()\n",
    "        \n",
    "        self.master_ends[0].send(('get_spaces', None))\n",
    "        self.observation_space, self.action_space = self.master_ends[0].recv()\n",
    "        \n",
    "    def step_async(self, actions):\n",
    "        for master_end, action in zip(self.master_ends, actions):\n",
    "            master_end.send(('step', action))\n",
    "        self.waiting = True\n",
    "    \n",
    "    def step_wait(self):\n",
    "        results = [master_end.recv() for master_end in self.master_ends]\n",
    "        self.waiting = False\n",
    "        states, rewards, dones, infos = zip(*results)\n",
    "        return np.stack(states), np.stack(rewards), np.stack(dones), infos\n",
    "    \n",
    "    def reset(self):\n",
    "        for master_end in self.master_ends:\n",
    "            master_end.send(('reset', None))\n",
    "        return np.stack([master_end.recv() for master_end in self.master_ends])\n",
    "    \n",
    "    def step(self, actions):\n",
    "        self.step_async(actions)\n",
    "        return self.step_wait()\n",
    "    \n",
    "    def close(self):\n",
    "        if self.closed:\n",
    "            return\n",
    "        if self.waiting:\n",
    "            [master_end.recv() for master_end in self.master_ends]\n",
    "        for master_end in self.master_ends:\n",
    "            master_end.send(('close', None))\n",
    "        del self.workers[:]\n",
    "        self.closed = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class Actor_critic(nn.Module):\n",
    "    def __init__(self, in_dim, out_dim):\n",
    "        super(Actor_critic, self).__init__()\n",
    "        self.actor_linear1 = nn.Linear(in_dim, 64)\n",
    "        self.critic_linear1 = nn.Linear(in_dim, 64)\n",
    "        self.linear2 = nn.Linear(64, 32)\n",
    "        self.actor_linear3 = nn.Linear(32, out_dim)\n",
    "        self.critic_linear3 = nn.Linear(32, 1)\n",
    "        self.sigma_linear = nn.Linear(32, out_dim)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        value_hidden = F.relu(self.linear2(F.relu(self.critic_linear1(x))))\n",
    "        value = self.critic_linear3(value_hidden)\n",
    "        actor_hidden = F.relu(self.linear2(F.relu(self.actor_linear1(x))))\n",
    "        mu = torch.tanh(self.actor_linear3(actor_hidden)) * 2\n",
    "        sigma = F.softplus(self.sigma_linear(actor_hidden))\n",
    "        dist = Normal(mu, sigma)\n",
    "        return dist, value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "画图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def smooth_plot(factor, item, plot_decay):\n",
    "    item_x = np.arange(len(item))\n",
    "    item_smooth = [np.mean(item[i:i+factor]) if i > factor else np.mean(item[0:i+1])\n",
    "                  for i in range(len(item))]\n",
    "    for i in range(len(item)// plot_decay):\n",
    "        item_x = item_x[::2]\n",
    "        item_smooth = item_smooth[::2]\n",
    "    return item_x, item_smooth\n",
    "    \n",
    "def plot(episode, rewards, losses):\n",
    "    clear_output(True)\n",
    "    rewards_x, rewards_smooth = smooth_plot(10, rewards, 500)\n",
    "    losses_x, losses_smooth = smooth_plot(10, losses, 100000)\n",
    "    \n",
    "    plt.figure(figsize=(18, 10))\n",
    "    plt.subplot(211)\n",
    "    plt.title('episode %s. reward: %s'%(episode, rewards_smooth[-1]))\n",
    "    plt.plot(rewards, label=\"Rewards\", color='lightsteelblue', linewidth='1')\n",
    "    plt.plot(rewards_x, rewards_smooth, label='Smothed_Rewards', color='darkorange', linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.subplot(212)\n",
    "    plt.title('Losses')\n",
    "    plt.plot(losses,label=\"Losses\",color='lightsteelblue',linewidth='1')\n",
    "    plt.plot(losses_x, losses_smooth, \n",
    "             label=\"Smoothed_Losses\",color='darkorange',linewidth='3')\n",
    "    plt.legend(loc='best')\n",
    "    \n",
    "    plt.show()\n",
    "    \n",
    "def test_env():\n",
    "    state = env.reset()\n",
    "    done = False\n",
    "    total_reward = 0\n",
    "    while not done:\n",
    "        state = torch.FloatTensor(state).reshape(-1, 3).to(device)\n",
    "        log_prob, _ = model(state)\n",
    "        next_state, reward, done, _ = env.step(log_prob.sample().cpu().numpy())\n",
    "        state = next_state\n",
    "        total_reward += reward\n",
    "    return total_reward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def gae_compute(next_value, rewards, masks, values, gamma=0.99, tau=0.95):\n",
    "    td_target = next_value\n",
    "    td_target_list = []\n",
    "    advantage = 0\n",
    "    advantage_list = []\n",
    "    for idx in reversed(range(len(values))):\n",
    "        td_target = td_target * gamma * masks[idx] + rewards[idx]\n",
    "        td_target_list.insert(0, td_target)\n",
    "        advantage = td_target - values[idx] + advantage * gamma * tau\n",
    "        advantage_list.insert(0, advantage)\n",
    "    return advantage_list, td_target_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PPO训练更新"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def ppo_iter(states, actions, log_probs, advantages, td_target_list):\n",
    "    batch_size = actions.size(0)\n",
    "    for _ in range(batch_size // mini_batch_size):\n",
    "        ids = np.random.choice(batch_size, mini_batch_size, replace=False)\n",
    "        yield states[ids, :], actions[ids, :], log_probs[ids, :], advantages[ids, :], td_target_list[ids, :]\n",
    "\n",
    "def ppo_train(states, actions, log_probs, advantages, td_target_list, clip_param=0.2):\n",
    "    losses = []\n",
    "    for _ in range(ppo_epochs):\n",
    "        for state, action, old_log_probs, advantage, td_target in ppo_iter(states, actions, log_probs,\n",
    "                                                                           advantages, td_target_list):\n",
    "            dist, value = model(state)\n",
    "            entropy = dist.entropy().mean()\n",
    "            new_log_probs = dist.log_prob(action)\n",
    "            \n",
    "            ratio = (new_log_probs - old_log_probs).exp() \n",
    "            sub1 = ratio * advantage\n",
    "            \n",
    "            sub2 = torch.clamp(ratio, 1.0-clip_param, 1.0+clip_param) * advantage\n",
    "            actor_loss = - torch.min(sub1, sub2).mean()\n",
    "            critic_loss = (td_target - value).pow(2).mean()\n",
    "            \n",
    "            loss = 0.5 * critic_loss + actor_loss - 0.001 * entropy\n",
    "            losses.append(loss.item())\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "        \n",
    "    old_model.load_state_dict(model.state_dict())        \n",
    "    return round(mean(losses),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "## hyperparameters ##\n",
    "\n",
    "num_envs = 16\n",
    "env_name = \"Pendulum-v0\"\n",
    "ppo_epochs = 30\n",
    "mini_batch_size = 256\n",
    "max_epoch = 10000\n",
    "num_timesteps = 128\n",
    "\n",
    "## hyperparameters ##\n",
    "\n",
    "envs = ParallelEnv(num_envs, env_name)\n",
    "state_space = envs.observation_space\n",
    "action_space = envs.action_space\n",
    "\n",
    "env = gym.make(env_name)\n",
    "\n",
    "model = Actor_critic(state_space, action_space).to(device)\n",
    "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
    "old_model = Actor_critic(state_space, action_space).to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "test_rewards = []\n",
    "loss_list = []\n",
    "state = envs.reset()\n",
    "\n",
    "for epoch in range(max_epoch):\n",
    "    states, actions, rewards, masks, log_probs, values = [], [], [], [], [], []\n",
    "    \n",
    "    for _ in range(num_timesteps):\n",
    "        dist, value = old_model(torch.FloatTensor(state).to(device))\n",
    "        action = dist.sample()\n",
    "        \n",
    "        next_state, reward, done, _ = envs.step(action.cpu().numpy())\n",
    "        \n",
    "        states.append(torch.FloatTensor(state).to(device))\n",
    "        actions.append(action)\n",
    "        rewards.append(torch.FloatTensor(reward).unsqueeze(1).to(device))\n",
    "        masks.append(torch.FloatTensor(1 - done).unsqueeze(1).to(device))\n",
    "        log_probs.append(dist.log_prob(action))\n",
    "        values.append(value)\n",
    "        \n",
    "        state = next_state\n",
    "        \n",
    "    _, next_value = model(torch.FloatTensor(next_state).to(device))\n",
    "    advantages, td_target_list = gae_compute(next_value, rewards, masks, values)\n",
    "    loss = ppo_train(torch.cat(states),torch.cat(actions), torch.cat(log_probs).detach(), \n",
    "                     torch.cat(advantages).detach(), torch.cat(td_target_list).detach())\n",
    "    loss_list.append(loss)\n",
    "    \n",
    "    if epoch % 1 == 0:\n",
    "        test_reward = np.mean([test_env() for _ in range(10)])\n",
    "        test_rewards.append(test_reward)\n",
    "        plot(epoch + 1, test_rewards, loss_list)\n",
    "#         soft = lambda loss : np.mean(loss[-100:]) if len(loss)>=100 else np.mean(loss)\n",
    "#         writer.add_scalar(\"Test_Rewards\", np.array(soft(test_rewards)), epoch)\n",
    "#         writer.add_scalar(\"Value_Losses\", np.array(soft(loss_list)), epoch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import display\n",
    "\n",
    "env = gym.make(env_name)\n",
    "state_1 = env.reset()\n",
    "img = plt.imshow(env.render(mode='rgb_array')) # only call this once\n",
    "for _ in range(1000):\n",
    "    img.set_data(env.render(mode='rgb_array')) # just update the data\n",
    "    display.display(plt.gcf())\n",
    "    display.clear_output(wait=True)\n",
    "    \n",
    "    prob, value = old_model(torch.FloatTensor(state_1).reshape(1,-1).to(device))\n",
    "    action = prob.sample().cpu().numpy()\n",
    "    next_state, _, done, _ = env.step(action)\n",
    "    if done: \n",
    "        state_1 = env.reset()\n",
    "    state_1 = next_state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PPO Baselines:\n",
    "<img src=\"../assets/PPO_baseline.png\"></img>\n",
    "### Test_Rewards:\n",
    "<img src=\"../assets/PPO_Test_Rewards.png\" width=100%></img>\n",
    "### Value_Losses:\n",
    "<img src=\"../assets/PPO_Value_Losses.png\"></img>"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
